diff --git a/sympy/core/basic.py b/sympy/core/basic.py
index 6866648d4e..bf75621750 100644
--- a/sympy/core/basic.py
+++ b/sympy/core/basic.py
@@ -434,10 +434,8 @@ def _repr_latex_(self):
     def atoms(self, *types):
         """Returns the atoms that form the current object.
 
-        By default, only objects that are truly atomic and can't
-        be divided into smaller pieces are returned: symbols, numbers,
-        and number symbols like I and pi. It is possible to request
-        atoms of any type, however, as demonstrated below.
+        This version is modified to return objects with no args instead of
+        subclasses of Atom.
 
         Examples
         ========
@@ -447,67 +445,13 @@ def atoms(self, *types):
         >>> (1 + x + 2*sin(y + I*pi)).atoms()
         {1, 2, I, pi, x, y}
 
-        If one or more types are given, the results will contain only
-        those types of atoms.
-
-        >>> from sympy import Number, NumberSymbol, Symbol
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)
-        {x, y}
-
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)
-        {1, 2}
-
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)
-        {1, 2, pi}
-
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)
-        {1, 2, I, pi}
-
-        Note that I (imaginary unit) and zoo (complex infinity) are special
-        types of number symbols and are not part of the NumberSymbol class.
-
-        The type can be given implicitly, too:
-
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol
-        {x, y}
-
-        Be careful to check your assumptions when using the implicit option
-        since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type
-        of sympy atom, while ``type(S(2))`` is type ``Integer`` and will find all
-        integers in an expression:
-
-        >>> from sympy import S
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
-        {1}
-
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))
-        {1, 2}
-
-        Finally, arguments to atoms() can select more than atomic atoms: any
-        sympy type (loaded in core/__init__.py) can be listed as an argument
-        and those types of "atoms" as found in scanning the arguments of the
-        expression recursively:
-
-        >>> from sympy import Function, Mul
-        >>> from sympy.core.function import AppliedUndef
-        >>> f = Function('f')
-        >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)
-        {f(x), sin(y + I*pi)}
-        >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)
-        {f(x)}
-
-        >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)
-        {I*pi, 2*sin(y + I*pi)}
-
         """
         if types:
             types = tuple(
                 [t if isinstance(t, type) else type(t) for t in types])
-        else:
-            types = (Atom,)
         result = set()
         for expr in preorder_traversal(self):
-            if isinstance(expr, types):
+            if isinstance(expr, Basic) and not expr.args:
                 result.add(expr)
         return result
 
